//common.js

/*函数节流*/
function throttle(fn, interval) {
  var enterTime = 0; //触发的时间
  var gapTime = interval || 300; //间隔时间，如果interval不传值，默认为300ms
  return function () {
    var that = this;
    var backTime = new Date(); //第一次函数return即触发的时间
    if (backTime - enterTime > gapTime) {
      fn.call(that, arguments);
      enterTime = backTime; //赋值给第一次触发的时间 保存第二次触发时间
    }
  };
}

/*函数防抖*/
function debounce(fn, interval) {
  var timer;
  var gapTime = interval || 600; //间隔时间 不传值默认为600ms
  return function () {
    clearTimeout(timer);
    var that = this;
    var args = arguments; //保存arguments setTimeout是全局的 arguments不是防抖函数需要的
    timer = setTimeout(function () {
      fn.call(that, args);
    }, gapTime);
  }
}
//首次触发执行，再次触发以后开始执行防抖函数
//使用的时候不用重复执行这个函数，本身返回的函数才具有防抖功能
function debounceImmediate(func, wait, immediate) {
  var timeout;
  return function () {
    var context = this;
    var args = arguments;

    if (timeout) clearTimeout(timeout);
    // 是否在某一批事件中首次执行
    if (immediate) {
      var callNow = !timeout;
      timeout = setTimeout(function () {
        timeout = null;
        func.apply(context, args)
        immediate = true;
      }, wait);
      if (callNow) {
        func.apply(context, args)
      }
      immediate = false;
    } else {
      timeout = setTimeout(function () {
        func.apply(context, args);
        immediate = true;
      }, wait);
    }
  }
}

/*导出*/
export default {
  throttle,
  debounce,
  debounceImmediate
};